Thread: reborn and jv-bots ?

Artificial Intelligence is one of the most complicated software to create. It requires a lot of patience, and you need to know what you're doing because due to
its nature the source code for AI applications is usually more dynamic and intertwined than your average code. You can't just drop into its world and expect
everything to be straightforward and simple.
Really, if it were that easy then jv or myself would've whipped up a perfect solution a long time ago. It requires months and months of writing, testing and dedication
(if you want a good implementation, that is).

AI components in all modern games are hardcoded, this means it'll always be written in C or C++, not that copy-pasting AI logic (potentially written with a completely
different implementation in mind) will magically solve every problem.
Besides I thought you wanted smart bots? If all you want them to do is hunt down other bots and players, then just manipulate the singleplayer bots.
Or rather, you should be editting jv_bots01 rather than version 3.

Originally Posted by Sor

Artificial Intelligence is one of the most complicated software to create. It requires a lot of patience, and you need to know what you're doing because due to
its nature the source code for AI applications is usually more dynamic and intertwined than your average code. You can't just drop into its world and expect
everything to be straightforward and simple.
Really, if it were that easy then jv or myself would've whipped up a perfect solution a long time ago. It requires months and months of writing, testing and dedication
(if you want a good implementation, that is).

AI components in all modern games are hardcoded, this means it'll always be written in C or C++, not that copy-pasting AI logic (potentially written with a completely
different implementation in mind) will magically solve every problem.
Besides I thought you wanted smart bots? If all you want them to do is hunt down other bots and players, then just manipulate the singleplayer bots.
Or rather, you should be editting jv_bots01 rather than version 3.

I must have a really crappy version of JVbots then. Does someone have his latest version working well on all maps including the obj ones? The version I have, the bots move to a place, stop, and just stand there waiting to shoot at enemies.

If there's a better version where they keep following path nodes and don't just retardedly stop, this is the version I want to mod. Bots don't need to be that smart... they just need to be able to kill you and offer some sort of a challenge. They just need to seem like they are players. Even the bots in CSGO suck, but my god, the version of bots I have is just atrocious. I think random strafing, leaning, and jumping combined with a better version of JVBots than the one I have would make a great bot mod...

That's probably true. Usually, the cost/work of making them 'even' more challenging or smarter is exponential to the actual result,
so in that respect you are right that there's no need to take it too far.

The 'stopping' in v1.1 is actually by design. Jv incorporated a task system where the most common were 'camping' and 'sniping',
both of which will make the bot go to a 'camp' or 'snipe' position and wait to ambush others. The problem with version 1 is that
the bots are way to static or maybe the one's doing the botaddons (myself for instance), made too much emphasis on it.

But the main culprit is the singleplayer AI they still operated under, I think, because it would make perfect sense to design
singleplayer AI to not have the need to explore but to make them stay put.

To be fair, jv's task system is also rather rigid and as he compares by direct distance in units; in other words, the further away,
the less priority a task gets which is diametrically opposed to exploration.

Do you have a version of JVBots that has all dm and obj maps mapped in terms of pathnodes and everything else I would need? I can take out the logic to camp and just sit there I suppose. What a stupid system. Bots should not be camping... we already hate when real players do that.

As Sor said, it's very complicated, since you want to create pathnodes dynamically, you have to take obstacles as simple as walls into consideration. Well.. it's easy to say, but if you want to have an intelligent bot, you can't define pathnodes, and pick from them because they will always move between those pathnodes. You should be able to add pathnodes dynamically and randomly, because your map is not a set of "dots", in this case pathnodes. If you split a map into pathnodes, your bot will never visit certain (x,y) coordinates because this will be impossible with a certain pathnodes mesh.

How I would go about it? Maybe Finite State Machine with probability weights, to create a simple fuzzy logic. This way your bot won't always act in the same manner to the same situations. You could define a decision vectors -> a vector of different factors that can make up decisions. You have to think what factors should be taken into consideration when making a decision. Then a fuzzy logic -> each factor has a wieght that stands for the importance of given factor. The wieghts can be dynamic based on previous states a bot was in, or decision vectors history, or world events history.

Based on that, the state machine would need to pick up an action that bot should do.

If the vector was built from factors like: [bot health, current x,y position, current map sector, last seen enemy position, last enemy fight position, ammo count, current area/surrounding state] it would need to decide wheter to seek for health, hide, attack, approach enemy etc.

For example, if you play FFA Stalingrad and you hear a fight in a nearby room, but you have a low health, you would rather ignore the fight and look for HP. However, sometimes you don't do this and you go into the fight or camp the room entrace or something. If you want to have intelligent bots, a simple logic won't do. You need a fuzzy logic. So the bot knows that he's low HP and SHOULD find HP boost, but it doesn't really mean that he will do that always.

And even after FSM picks a decision, another algorithm has to decide how to go about that decision. How to achieve it.
For example, FSM decides to approach certain enemy. Now you have to decide HOW TO DO THAT. Which way to go, which way to move. The shortest one? The safest one? The most unpredictable one? Which one is the safest in the current state, which one is shortest, which one can surprise an enemy?

Lets say you jave your A (x y z) position and enemy's B (x y z) position. You can't just go forward from A to B in a straight line.
You can have a pathnode mesh, find a node that is the closest one to the B point (even this can be a very advanced algo, because it has to do the job fast) and using another algorithm, connect the nodes into the path that bot should follow.

But what about A point? You can find the closest pathnode to the A point, make a "virtual" node from A point and add it to the path. Or you can just make a node from A point, and now you have to recalculate the pathnode graph. What's more.. you know enemy position, but you don't want to go to the B point exactly, but to a nearby area where this point is located, or even go to a totally different map area from where you can shoot to point B area.

Let's say we've done that job. We start to move the bot. How we should act when certain events occur during that? Should we change bot's behaviour? Or continue? Again FSM should help us somehow.

Even a simple FSM will have to have a lot of different states. Add fuzzy logic, decision vectors and probability to this. This is very complex.

Now how would you go about the pathnodes. Would you want to analyze the map first, and create a mesh with nodes connected into the graph? If you choose that way, you won't be able to move your bots from any (x, y, z) to any (x, y, z) because you will have a discrete map points only which will be your nodes.

Would you just pick up a closest node to the B point, and then randomly pick up a final point in the close area of the B point?

You could also want to implement an ant-algorithm (ACO http://en.wikipedia.org/wiki/Ant_col...ion_algorithms). Or a genetic algorithm.

But if we wanted a true dynamic approach, we would need to know something about the surrounding buildings, use traces and select a discrete (x, y, z) point which will be move you closer to the achievement. This is for "take shortest path" decision. For "take safest path" decision, the distance won't be a crucial factor for the algorith to pick up the next point, but probably a distance from all other enemies at that point.


A lot of things to consider, and a lot of work to implement this.

Here is an interesting analysis of Quake3 bots I stumbled upon. It mentions few things I proposed here, like fuzzy activation factor, state machine etc. It also describes some different approaches like behaviour trees etc.

EDIT:

Here - http://www.kbs.twi.tudelft.nl/docs/M...van/thesis.pdf http://aigamedev.com/open/article/quake3-engine/

@Razo: There's no link, but if I think I know to what you are referring to. I immediately thought of that paper once you starting talking about fuzzy logic and FSMs.
The original source appears to be gone but I've found a copy:
Quake III Arena Bot thesis paper (2001).pdf

It's still on my to-read list. But I assume some things may not hold true for the AI implementation in the games following that used and modified the Q3-engine.
I'll have to read up on fuzzy logic but the way you described it helped a lot. Seems to do what I wanted to do with neural networks but in a more simpler manner.

The ant colony optimization seems like a graceful way to handle pathfinding bottlenecks. Depending on the map, on some locations the bots may all choose the same
subpath and go their own way from then on, simply because any alternative is more costful as per the standard pathfinding algorithms. But with this the algorithm
won't just take 'cost' or 'distance' into account but also 'benefit'. For instance if a bot chooses a path that's the shortest but keeps getting ambushed along the way,
he may pick another one. If the attacks are less frequent than they would have on the path he normally would choose, then nodes he passed so far on the current path
are 'promoted' to indicate to the algorithm (and therefore the other bots (may need to be team-specific )) that paths using these nodes may be better than the shortest path.

Now this gets interesting if we apply the same logic to the ambushers and attackers. If the camp/snipe or assault locations become less populous, they could venture
further and stumble upon the 'promoted' paths to terrorize them again. In this case, logic above kicks in again and the bots will start to find other routes again.

The great thing about it is it can be applied to both 'attacking bots' and 'defending bots'. The attackers usually consist of 'hunters' who just hunt down enemies and
a batch of bots set out to complete a few tasks (like setting bombs). Likewise the defenders, have 'ambushers' who find the ideal killing locations and the bots who
defend key positions.

This way of making them 'indirectly', almost implicitly, look for each other is a lot more natural and gets a lot more dynamic because paths and their interconnected lay-outs
vary per map. Almost like herbivores (avoiding carnivores) vs. carnivores (seeking herbivores) and everyone's packing heat so it evens out the gameplay.

Also, I don't understand why people are against pathnodes? You shouldn't see them only as nodes. For instance, what can 4 nodes represent?
While most would say 'a path', I say 'an area or surface in the gameworld, almost like a primitive form of navmeshing'.


@own3mall: Haha, now we hate them but this mod was released back in 2003 when it was still considered 'acceptable'. The pathnodes are defined in the .bot file that is
associated with each compatible map. The first section of the file contains the nodes, this gets exec'd. The second part contains spawnpoint, objective, camper and sniper
nodes. So downloading each map and extracting the pathnode portion of the .bot file is all you need to do to get the nodes themselves.

My dad (mostly) and I did a 150 maps back in the day so there are enough pathnode definitions around I think. You won't have to occupy yourself with the tedious task of
adding them to maps and then filtering out the bad ones. It's the kind of task that gets on my nerves... which is why I'd much rather write a very complicated script that
does it all for me. Anyway, if you're redoing version 1, you shouldn't have to worry about nodes too much.

The thing about 'smart' bots is not that they're more human or more challenging, it's that they are more unpredictable. The simpler the bots are, the more predictable
they become. So if one designs bots that just run up and try to kill you, then even if they are a crack shot and the encounters are random, the human player will know
exactly how the bots work and before long he'll even outgun them. At this point, the bots have already defeated their own purpose because the player is already bored
and will likely not be playing with them anytime soon. So you could put it another way: AI isn't difficult, but entertaining humans is.

The funny things is I wrote the post, then started to look for something more and found that thesis which just mentions things I wrote about earlier

Anyway, fuzzy logic is quite simple to understand. In binary logic you have only YES/NO, TRUE/FALSE, 0/1. Fuzzy logic describes how much something is true and how much something is false, or just gives you more options maybe true, maybe false etc.

It's like with the world, some people see it in black&white, good&evil, while other see a whole gray scale or even colours.

You can read about the fuzzy sets here http://en.wikipedia.org/wiki/Fuzzy_set While the idea is simple, operations on such values are harder, but for our use you could look at it as a probability for decision being a member of a specific decisions set etc.

NN can learn and adjust weights (fuzzy logic membership factors).

Ant algorithms and swarm algorithms (checkout swarm intelligence algorithms because ant alg is a variation of it http://en.wikipedia.org/wiki/Swarm_intelligence) in general can adjust to changing dinamic environment on-the-fly which quite good.

Yes, a single node can represent a room. But you actually have to implement movement in the room too.

How would you want to dynamically generate pathnodes/waypoints? Tracing whole map before the game starts or what? If you read about Quakes waypoints and navigation (AAS) you will know that they build simplified world 3d model from map BSP.

MoHAA can do almost the same. I think it can even provide us with ready functions for mapping BSP and choosing area portals.